with v8.Class_Value, v8.Class_Message, v8.Class_Stack_Trace;
private with Ada.Finalization;
package v8.Class_Try_Catch is
   type Try_Catch (<>) is limited private;
   type Pointer is access all Try_Catch;
   type Holder is tagged limited private;
   -- An external exception handler.

   function Has_Caught (this : Holder) return Boolean;
   -- Returns true if an exception has been caught by this try/catch block.

   function Can_Continue (this : Holder) return Boolean;
   -- For certain types of exceptions, it makes no sense to continue
   -- execution.
   --
   -- Currently, the only type of exception that can be caught by a
   -- TryCatch handler and for which it does not make sense to continue
   -- is termination exception.  Such exceptions are thrown when the
   -- TerminateExecution methods are called to terminate a long-running
   -- script.
   --
   -- If CanContinue returns false, the correct action is to perform
   -- any C++ cleanup needed and then return.

   function Re_Throw (this : in out Holder) return v8.Class_Value.Pointer;
   -- Throws the exception caught by this TryCatch in a way that avoids
   -- it being caught again by this same TryCatch.  As with ThrowException
   -- it is illegal to execute any JavaScript operations after calling
   -- ReThrow; the caller must return immediately to where the exception

   function Get_Exception (this : Holder) return v8.Class_Value.Pointer;
   -- Returns the exception caught by this try/catch block.  If no exception has
   -- been caught an empty handle is returned.
   --
   -- The returned handle is valid until this TryCatch block has been destroyed.

   function Stack_Trace (this : Holder) return v8.Class_Stack_Trace.Pointer;
   -- Returns the .stack property of the thrown object.  If no .stack
   -- property is present an empty handle is returned.

   function Message (this : Holder) return v8.Class_Message.Pointer;
   -- Returns the message associated with this exception.  If there is
   -- no message associated an empty handle is returned.
   --
   -- The returned handle is valid until this TryCatch block has been
   -- destroyed.

   procedure Reset (this : in out Holder);
   -- Clears any exceptions that may have been caught by this try/catch block.
   -- After this method has been called, HasCaught() will return false.
   --
   -- It is not necessary to clear a try/catch block before using it again; if
   -- another exception is thrown the previously caught exception will just be
   -- overwritten.  However, it is often a good idea since it makes it easier
   -- to determine which operation threw a given exception.

   procedure Set_Verbose (this : in out Holder; value : Boolean);
   -- Set verbosity of the external exception handler.
   --
   -- By default, exceptions that are caught by an external exception
   -- handler are not reported.  Call SetVerbose with true on an
   -- external exception handler to have exceptions caught by the
   -- handler reported as if they were not caught.

   procedure Set_CaptureMessage (this : in out Holder; value : Boolean);
   -- Set whether or not this TryCatch should capture a Message object
   -- which holds source information about where the exception
   -- occurred.  True by default.

   function As_Try_Catch (this : Holder) return Pointer;
   -- return C++ *TryCatch

private

   type Try_Catch is limited record
      isolate_u         : System.Address;  -- ../include/v8.h:3301
      next_u            : System.Address;  -- ../include/v8.h:3302
      exception_u       : System.Address;  -- ../include/v8.h:3303
      message_u         : System.Address;  -- ../include/v8.h:3304
      is_verbose_u      : aliased bool;  -- ../include/v8.h:3305
      can_continue_u    : aliased bool;  -- ../include/v8.h:3306
      capture_message_u : aliased bool;  -- ../include/v8.h:3307
      rethrow_u         : aliased bool;  -- ../include/v8.h:3308
   end record;

   function Create return Try_Catch;  -- ../include/v8.h:3213


   type Holder is new Ada.Finalization.Limited_Controlled with record
      Internal : aliased Try_Catch;
   end record;

   overriding procedure Initialize(this : in out Holder);

   overriding procedure Finalize (This : in out Holder);

   pragma Import (CPP, Try_Catch);
   pragma CPP_Constructor (Create, "_ZN2v88TryCatchC1Ev");




end v8.Class_Try_Catch;
